Clase 1 - Programacion Funcional

Reiniciar R

library(tidyverse)
library(openxlsx)
library(ggthemes)
library(fs)

Loops

Un loop es una estructura de código que nos permite aplicar iterativamente un mismo conjunto de comandos, variando el valor de una variable. Por ejemplo:

for(i in 1:10){
   print(i^2)
}

[1] 1
[1] 4
[1] 9
[1] 16
[1] 25
[1] 36
[1] 49
[1] 64
[1] 81
[1] 100

Esto se lee como : “Recorre cada uno de los valores (i) del vector numérico 1 a 10, y para cada uno de ellos imprimí el cuadrado (i^2)”.
Uno puede especificar la palabra que desee que tomé cada uno de los valores que debe tomar. En el ejemplo anterior fue i, pero bien podría ser la “Valores”

for(Valores in 1:10){
   print(Valores^2)
  
}

[1] 1
[1] 4
[1] 9
[1] 16
[1] 25
[1] 36
[1] 49
[1] 64
[1] 81
[1] 100

Un loop puede iterar sobre cualquier tipo de vector, independientemente de lo que contenga.

Los loops son una estructura básica que existen en cualquier lenguaje de programación. En R no recomendamos abusar de ellos porque hacen que el código sea más lento.

Estructuras Condicionales

Las estructuras condiconales nos permiten ejecutar una porción de código en caso de que cumplan una condición lógica

if

Su funcionamiento es el siguiente:
if(condicion){codigo a ejecutar si se cumple la condición}

if( 2+2 == 4){
  print("Menos Mal")
}

[1] "Menos Mal"

if( 2+2 == 148.24){
  print("R, tenemos un problema")
}

ifelse

La función if_else() sirve para crear o modificar dicotómicamente un objeto/variable/vector a partir del cumplimiento de una o más condiciones lógicas.
Su funcionamiento es el siguiente:
if_else(condicion,función a aplicar si se cumple la condición,función a aplicar si no se cumple la condición)

if_else(2+2==4, true = "Joya",false = "Error")

[1] "Joya"

Funciones

La creación de funciones propias nos permite automatizar todas aquellas partes del código que se repiten mucho. Una vez diseñadas, funcionan igual que cualquier comando.

Por ejemplo, podemos definir la suma de dos elementos como

suma <- function(valor1, valor2) {
  valor1+valor2
}
suma(5,6)

[1] 11

Obviamente las funciones no son sólo para variables numéricas. Por ejemplo, podemos pegar dos strings con una flecha en el medio

funcion_prueba <- function(parametro1,parametro2) {
  paste(parametro1, parametro2, sep = " <--> ")
}
funcion_prueba(parametro1 = "A ver", parametro2 = "Que pasa")

[1] "A ver <--> Que pasa"

También podemos asignar un valor por default para los parametros en caso de que el usuario no defina su valor al utilizar la función.

Otra_funcion_prueba <- function(parametro1 ,parametro2 = "String default") {
  paste(parametro1, parametro2, sep = " <--> ")
  
}
Otra_funcion_prueba(parametro1 = "Valor 1 ")

[1] "Valor 1  <--> String default"

Las funciones que creamos nosotros permanecen en el ambiente de R temporariamente. Cuando removemos los objetos del ambiente, la función deja de existir. Por ende, debemos incorporarla en cada uno de los scripts en la cual la necesitemos. Una buena práctica, es incorporar nuestras funciones útiles al comienzo de cada script junto a la carga de las librerías.

Vale mencionar que lo que ocurre en una función, queda en la función excepto que explícitamente pidamos que devuelva el resultado, con el comando print().

Las funciones siempre devuelven el último objeto que se crea en ellas, o si explicitamente se utiliza el comando return()

Funciones anónimas

Son funciones a las cuales no les asignamos un nombre. Esto suele ser útil para hacer funciones pequeñas dentro de otras funciones o estructuras más complejas.

(function(x) x*2)(10)

[1] 20

PURRR¹

MAP es la forma tidy de hacer loops. Además de ser más prolijo el código, es mucho más eficiente.

La función map toma un input, una función para aplicar, y alguna otra cosa (por ejemplo parametros que necesite la función)

• map(.x, .f, …)
• map(VECTOR_O_LIST_INPUT, FUNCTION_A_APLICAR, OTROS_OPCIONALES)

Usamos map2 cuando tenemos que pasar dos input, que se aplican sobre una función:

• map2(.x, .y, .f, …)
• map2(INPUT_UNO, INPUT_DOS, FUNCTION_A_APLICAR, OTROS_OPCIONALES)

Si tenemos más de dos…

• pmap(.l, .f, …)
• pmap(VECTOR_O_LIST_INPUT, FUNCTION_A_APLICAR, OTROS_OPCIONALES)

Por ejemplo. Si queremos utilizar la función prueba sobre los datos del dataframe ABC_123

ABC_123 <- data.frame(Letras = LETTERS[1:20],Num = 1:20)
funcion_prueba

function(parametro1,parametro2) {
  paste(parametro1, parametro2, sep = " <--> ")
}

Si el resultado que queremos es que junte cada fila, necesitamos pasarle dos parámetros: utilizamos map2(), Noten que la función se le pasa a map() sin paréntesis ni argumentos.

resultado <- map2(.x = ABC_123$Letras, .y = ABC_123$Num,.f = funcion_prueba)
resultado[1:3]

[[1]]
[1] "A <--> 1"

[[2]]
[1] "B <--> 2"

[[3]]
[1] "C <--> 3"

La salida de los map() es una lista, no un vector, por lo que si lo metemos dentro de un dataframe se vería así:

ABC_123 %>% 
  mutate(resultado= map2(.x = Letras,.y = Num,.f = funcion_prueba))

Al ponerlo dentro del dataframe desarma la lista y guarda cada elemento por separado. La magia de eso es que podemos guardar cualquier cosa en el dataframe no sólo valores, sino también listas, funciones, dataframes, etc.

Si queremos recuperar los valores originales en este caso podemos usar unlist()

# Recuperamos los tres primeros elementos de la lista resultados
resultado[1:3] %>% unlist()

[1] "A <--> 1" "B <--> 2" "C <--> 3"

# Recuperamos el elemento de la lista para cada par letra-numero (cada fila)
ABC_123 %>% 
  mutate(resultado= unlist(map2(.x = Letras,.y = Num,.f = funcion_prueba)))

Si lo que queríamos era que la función nos haga todas las combinaciones de letras y número, entonces lo que necesitamos es pasarle el segúndo parametro como algo fijo, poniendolo después de la función.

Notemos que estamos utilizando map() que toma un único input, en lugar de map2()

#Combinacion de todas las letras con todos los numeros
map(.x = ABC_123$Letras,.f = funcion_prueba,ABC_123$Num)[1:2]

[[1]]
 [1] "A <--> 1"  "A <--> 2"  "A <--> 3"  "A <--> 4"  "A <--> 5"  "A <--> 6"  "A <--> 7"  "A <--> 8"  "A <--> 9" 
[10] "A <--> 10" "A <--> 11" "A <--> 12" "A <--> 13" "A <--> 14" "A <--> 15" "A <--> 16" "A <--> 17" "A <--> 18"
[19] "A <--> 19" "A <--> 20"

[[2]]
 [1] "B <--> 1"  "B <--> 2"  "B <--> 3"  "B <--> 4"  "B <--> 5"  "B <--> 6"  "B <--> 7"  "B <--> 8"  "B <--> 9" 
[10] "B <--> 10" "B <--> 11" "B <--> 12" "B <--> 13" "B <--> 14" "B <--> 15" "B <--> 16" "B <--> 17" "B <--> 18"
[19] "B <--> 19" "B <--> 20"

En este caso, el map itera sobre cada elemento de letras, y para cada elemento i hace funcion_prueba(i,ABC$Num) y guarda el resultado en la lista

Si lo queremos meter en el dataframe:

# Asignar resultado al dataframe
ABC_123 %>% 
  mutate(resultado= map(Letras,funcion_prueba,Num))

Ahora cada fila tiene una lista de 20 elementos guardado en la columna resultado

Funciones implícitas/anonimas

No es necesario que definamos la función de antemano. Podemos usar funciones implícitas

# Calculamos el cuadrado de cada elemento
map_dbl(.x = c(1:10), .f = function(x) x^2) 

 [1]   1   4   9  16  25  36  49  64  81 100

# Calculamos el producto para los elementos x e y
map2_dbl(.x = c(1:10),.y = c(11:20),.f =  function(x,y) x*y)

 [1]  11  24  39  56  75  96 119 144 171 200

Funciones lambda

Incluso más conciso que las funciones implíictas son las funciones lambda donde definimos las variables como .x .y, etc. La flexibilidad de estas expresiones es limitada, pero puede ser útil en algunos casos.

# Calculamos el cuadrado de cada elemento
map_dbl(.x = c(1:10),.f = ~.x^2)

 [1]   1   4   9  16  25  36  49  64  81 100

# Calculamos el producto para los elementos x e y
map2_dbl(.x = c(1:10),.y = c(11:20),.f = ~.x*.y)

 [1]  11  24  39  56  75  96 119 144 171 200

Ejemplo: Iterando en la EPH

Lo primero que necesitamos es definir un vector o lista sobre el que iterar.

Por ejemplo, podemos armar un vector con los path a las bases individuales, con el comando fs::dir_ls. Se le especifica el path donde buscar los archivos y en este caso una expresion regular regexp para que devuelva aquellos archivos que coinciden con la misma.

# Buscamos en el path aquellos aquellos archivos que matchean a la expresion regular
bases_individuales_path <- dir_ls(path = '../Fuentes/', regexp= 'individual')
bases_individuales_path

../Fuentes/usu_individual_t117.txt ../Fuentes/usu_individual_t216.txt ../Fuentes/usu_individual_t316.txt 
../Fuentes/usu_individual_t416.txt 

Luego, como en la función que usamos para leer las bases definimos muchos parametros, nos podemos armar una función wrapper que sólo necesite un parámetro, y que simplifique la escritura del map.

# Leer la base de EPH tomando como argumento el file_path
leer_base_eph <- function(path) {
  # Lectura de archivo
  read.table(path,sep=";", dec=",", header = TRUE, fill = TRUE) %>%
    # Seleccion de variables relevantes
    select(ANO4,TRIMESTRE,REGION,P21,CH04, CH06)
}
# Leer a un dataframe las tablas especificadas en el vector de bases individuales
bases_df <- tibble(bases_individuales_path) %>%
  mutate(base = map(.x = bases_individuales_path, .f = leer_base_eph))

bases_df

El resultado es un dataframe donde la columna base tiene en cada fila otro dataframe con la base de la EPH de ese período. Esto es lo que llamamos un nested DF o dataframe anidado.

Si queremos abrir (“desanidar”) estas dataframes anidados usamos el comando unnest()

# Desanidamos el dataframe
bases_df <- bases_df %>% unnest()
bases_df

¿Qué pasa si los DF que tenemos nesteados no tienen la misma cantidad de columnas?

Esto mismo lo podemos usar para fragmentar el dataset por alguna variable, con la funcion group_by()

bases_df %>% 
  # Agrupar por region
  group_by(REGION) %>% 
  # Anidar
  nest()

Así, para cada región tenemos un DF.

¿ De qué sirve todo esto?

No todo en la vida es un Dataframe. Hay estucturas de datos que no se pueden normalizar a filas y columnas. En esos casos recurríamos tradicionalmente a los loops. Con MAP podemos tener los elementos agrupados en un sólo objeto y aún conservar sus formas diferentes.

Ejemplo. Regresión lineal

Si bien no nos vamos a meter en el detalle del modelo lineal en este encuentro, es útil usarlo como ejemplo de lo que podemos hacer con MAP.

Planteamos el modelo \[ P21 = \beta_0 + \beta_1*CH04 + \beta_2*CH06 \]

Es un modelo que explica el ingreso (P21) en funcion del sexo (CH04) y edad (CH06)

# Calculamos una regresion lineal sobre el dataset que tiene todas las observaciones de EPH
lmfit <- lm(P21~factor(CH04)+CH06,data = bases_df)
# Resumen del modelo
summary(lmfit)

Call:
lm(formula = P21 ~ factor(CH04) + CH06, data = bases_df)

Residuals:
   Min     1Q Median     3Q    Max 
 -8449  -3631  -1938    705 393616 

Coefficients:
                Estimate Std. Error t value Pr(>|t|)    
(Intercept)    2599.1101    29.0732   89.40   <2e-16 ***
factor(CH04)2 -2250.9637    28.3026  -79.53   <2e-16 ***
CH06             57.3490     0.6347   90.35   <2e-16 ***
---
Signif. codes:  0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1

Residual standard error: 6858 on 236187 degrees of freedom
Multiple R-squared:  0.05449,   Adjusted R-squared:  0.05448 
F-statistic:  6805 on 2 and 236187 DF,  p-value: < 2.2e-16

(al final de la clase podemos charlar sobre los resultados)

De forma Tidy, la librería broom nos da los resultados sobre los coeficientes en un DF.

broom::tidy(lmfit)

Si lo queremos hacer por region

Loopeando

resultados <- tibble()
for (region in unique(bases_df$REGION)) {
  # Creamos un dataset por region
  data <- bases_df %>% 
    filter(REGION==region)
  # Calcular el modelo lineal
  lmfit <- lm(P21~factor(CH04)+CH06,data = data)
  # Guardar los resultados de los coeficientes 
  lmtidy <- broom::tidy(lmfit)
  # Asignamos la variable region
  lmtidy$region <- region
  # Unimos los dataframes
  resultados <- bind_rows(resultados,lmtidy)
}
resultados

Usando MAP

Primero me armo una funcion que me simplifica el codigo. La funcion nos devuelve la informacion de los coeficientes del modelo lineal calculado sobre el dataframe porcion

fun<-function(porcion,grupo) {  broom::tidy(lm(P21~factor(CH04)+CH06,data = porcion))}

bases_df_lm <- bases_df %>% 
  # Agrupamos por region
  group_by(REGION) %>%
  # Anidamos
  nest() %>% 
  # Creamos una columna que tenga el dataframe como resultado de la funcion
  mutate(lm = map(data,fun))
bases_df_lm

# Desanidamos por la variable lm
bases_df_lm %>% 
  unnest(lm)

O incluso más facil, utilizando group_modify (que es un atajo que solo acepta DF)

bases_df %>% 
  group_by(REGION) %>% 
  group_modify(fun)

Pero MAP sirve para operar con cualquier objeto de R.

Por ejemplo podemos guardar el objeto S3:lm que es la regresion lineal entrenada. Ese objeto no es ni un vector, ni una lista, ni un DF. No es una estructura de datos, sino que es algo distinto, con propiedades como predict() para predecir, el summary() que vimos, etc.

# La funcion calcula el modelo lineal sobre cada porcion de datos
fun<-function(porcion,grupo) {  lm(P21~factor(CH04)+CH06,data = porcion)}
bases_df %>%
  # Agrupar por region
  group_by(REGION) %>%
  # Anidar
  nest() %>%
  # Calcular el modelo lineal
  mutate(lm = map(data,fun))

Walk

Las funciones Walk Tienen la misma forma que los map, pero se usan cuando lo que queremos iterar no genera una salida, sino que nos interesan los efectos secundarios que generan.

map2(.x = ABC_123$Letras,.y = ABC_123$Num,.f = funcion_prueba)[1:3]

[[1]]
[1] "A <--> 1"

[[2]]
[1] "B <--> 2"

[[3]]
[1] "C <--> 3"

walk2(.x = ABC_123$Letras,.y = ABC_123$Num,.f = funcion_prueba)

Notemos que walk2 no devolvió un resultado

# funcion para imprimir
imprimir_salida <- function(x,y){
  print(funcion_prueba(x,y))
}
# Map
map2(ABC_123$Letras,ABC_123$Num,imprimir_salida)

[1] "A <--> 1"
[1] "B <--> 2"
[1] "C <--> 3"
[1] "D <--> 4"
[1] "E <--> 5"
[1] "F <--> 6"
[1] "G <--> 7"
[1] "H <--> 8"
[1] "I <--> 9"
[1] "J <--> 10"
[1] "K <--> 11"
[1] "L <--> 12"
[1] "M <--> 13"
[1] "N <--> 14"
[1] "O <--> 15"
[1] "P <--> 16"
[1] "Q <--> 17"
[1] "R <--> 18"
[1] "S <--> 19"
[1] "T <--> 20"
[[1]]
[1] "A <--> 1"

[[2]]
[1] "B <--> 2"

[[3]]
[1] "C <--> 3"

[[4]]
[1] "D <--> 4"

[[5]]
[1] "E <--> 5"

[[6]]
[1] "F <--> 6"

[[7]]
[1] "G <--> 7"

[[8]]
[1] "H <--> 8"

[[9]]
[1] "I <--> 9"

[[10]]
[1] "J <--> 10"

[[11]]
[1] "K <--> 11"

[[12]]
[1] "L <--> 12"

[[13]]
[1] "M <--> 13"

[[14]]
[1] "N <--> 14"

[[15]]
[1] "O <--> 15"

[[16]]
[1] "P <--> 16"

[[17]]
[1] "Q <--> 17"

[[18]]
[1] "R <--> 18"

[[19]]
[1] "S <--> 19"

[[20]]
[1] "T <--> 20"

# Walk
walk2(ABC_123$Letras,ABC_123$Num,imprimir_salida)

[1] "A <--> 1"
[1] "B <--> 2"
[1] "C <--> 3"
[1] "D <--> 4"
[1] "E <--> 5"
[1] "F <--> 6"
[1] "G <--> 7"
[1] "H <--> 8"
[1] "I <--> 9"
[1] "J <--> 10"
[1] "K <--> 11"
[1] "L <--> 12"
[1] "M <--> 13"
[1] "N <--> 14"
[1] "O <--> 15"
[1] "P <--> 16"
[1] "Q <--> 17"
[1] "R <--> 18"
[1] "S <--> 19"
[1] "T <--> 20"

Eso que vemos es el efecto secundario dentro de la función (imprimir)

Discusión.

¿Cuándo usar estas herramientas?

A lo largo del curso vimos diferentes técnicas para manipulación de datos. En particular, la librería dplyr nos permitía fácilmente modificar y crear nuevas variables, agrupando. ¿Cuando usamos dplyr y cuando usamos purrr?

• Si trabajamos sobre un DF simple, sin variables anidadas (lo que conocíamos hasta hoy) podemos usar dplyr

• Si queremos trabajar con DF anidados, con cosas que no son DF, o si el resultado de la operación que vamos a realizar a nivel archivo es algo distinto a un valor único, nos conviene usar map y purrr

• Las funciones walk son útiles por ejemplo para escribir archivos en disco de forma iterativa. Algo que no genera una salida

Ejercicios para practicar

• Crear una función llamada HolaMundo que imprima el texto “Hola mundo”

• Crear una función que devuelva la sumatoria de los números enteros comprendidos entre 1 y un parámetro x a definir.

• Crear una función que calcule la frecuencia expandida por un PONDERA

• Utilizar dicha función para calcular la frecuencia poblaciónal por Sexo y Región

• Modificar la función anterior para que devuelva un vector con la frecuencia muestra y la frecuencia poblacional

• Utilizar la función modificada para calcular la frecuencias frecuencias muestrales y poblacionales por Sexo y Región

---

1. basado en https://jennybc.github.io/purrr-tutorial/ls03_map-function-syntax.html↩